# Source: https://github.com/IntelLabs/fastRAG/blob/main/fastrag/generators/replug.py
# The release is licensed under the Apache License 2.0

import warnings
from typing import List, Optional, Union
# import transformers
# from transformers import (
#     MODEL_FOR_CAUSAL_LM_MAPPING,
#     AutoConfig,
#     GenerationMixin,
#     LogitsProcessor,
#     LogitsProcessorList,
#     StoppingCriteriaList,
# )
# import torch
# import torch.nn as nn
# import torch.distributed as dist
# from transformers.generation.stopping_criteria import validate_stopping_criteria
# from transformers.generation.utils import (
#     SampleDecoderOnlyOutput,
#     SampleEncoderDecoderOutput,
#     SampleOutput,
# )

import paddle
import paddle.nn as nn
import paddle.distributed as dist
import paddlenlp.transformers
from paddlenlp.transformers import AutoConfig
from paddlenlp.generation import (
    GenerationMixin,
    LogitsProcessor,
    LogitsProcessorList,
    StoppingCriteriaList,
)
from paddlenlp.generation.stopping_criteria import validate_stopping_criteria
# from paddlenlp.generation.utils import (
    # SampleDecoderOnlyOutput,
    # SampleEncoderDecoderOutput,
    # SampleOutput,
# )


class REPLUG_Generation(GenerationMixin):
    """Implementing REPLUG-based sampling text generation."""

    def sample(
        self,
        input_ids: paddle.Tensor,
        logits_processor: Optional[LogitsProcessorList] = None,
        stopping_criteria: Optional[StoppingCriteriaList] = None,
        logits_warper: Optional[LogitsProcessorList] = None,
        max_length: Optional[int] = None,
        pad_token_id: Optional[int] = None,
        eos_token_id: Optional[Union[int, List[int]]] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        output_scores: Optional[bool] = None,
        return_dict_in_generate: Optional[bool] = None,
        synced_gpus: bool = False,
        streamer: Optional["BaseStreamer"] = None,
        **model_kwargs,
    # ) -> Union[SampleOutput, paddle.Tensor]:
    ):
        # init values
        logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()
        stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()
        if max_length is not None:
            warnings.warn(
                "`max_length` is deprecated in this function, use"
                " `stopping_criteria=StoppingCriteriaList(MaxLengthCriteria(max_length=max_length))` instead.",
                UserWarning,
            )
            stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)
        logits_warper = logits_warper if logits_warper is not None else LogitsProcessorList()
        pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id
        eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id
        if isinstance(eos_token_id, int):
            eos_token_id = [eos_token_id]
        eos_token_id_tensor = paddle.to_tensor(data=eos_token_id).to(input_ids.place) if eos_token_id is not None else None
        output_scores = output_scores if output_scores is not None else self.generation_config.output_scores
        output_attentions = (
            output_attentions if output_attentions is not None else self.generation_config.output_attentions
        )
        output_hidden_states = (
            output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states
        )
        return_dict_in_generate = (
            return_dict_in_generate
            if return_dict_in_generate is not None
            else self.generation_config.return_dict_in_generate
        )

        # init attention / hidden states / scores tuples
        scores = () if (return_dict_in_generate and output_scores) else None
        decoder_attentions = () if (return_dict_in_generate and output_attentions) else None
        cross_attentions = () if (return_dict_in_generate and output_attentions) else None
        decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None

        # if model is an encoder-decoder, retrieve encoder attention weights and hidden states
        if return_dict_in_generate and self.config.is_encoder_decoder:
            encoder_attentions = model_kwargs["encoder_outputs"].get("attentions") if output_attentions else None
            encoder_hidden_states = (
                model_kwargs["encoder_outputs"].get("hidden_states") if output_hidden_states else None
            )

        # keep track of which sequences are already finished
        unfinished_sequences = paddle.ones(input_ids.shape[0], dtype='int64').to(input_ids.place)

        this_peer_finished = False  # used by synced_gpus only
        # auto-regressive generation
        while True:
            if synced_gpus:
                # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.
                # The following logic allows an early break if all peers finished generating their sequence
                this_peer_finished_flag = paddle.to_tensor(0.0 if this_peer_finished else 1.0).to(input_ids.palce)
                # send 0.0 if we finished, 1.0 otherwise
                dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)
                # did all peers finish? the reduced sum will be 0.0 then
                if this_peer_finished_flag.item() == 0.0:
                    break

            # prepare model inputs
            model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)

            # forward pass to get next token
            outputs = self(
                **model_inputs,
                return_dict=True,
                output_attentions=output_attentions,
                output_hidden_states=output_hidden_states,
            )

            if synced_gpus and this_peer_finished:
                continue  # don't waste resources running the code we don't need

            next_token_logits = outputs.logits[:, -1, :]

            # pre-process distribution
            ### REPLUG - document weighting is done via REPLUGLogitsProcessor
            next_token_scores = logits_processor(input_ids, next_token_logits)
            next_token_scores = logits_warper(input_ids, next_token_scores)

            # Store scores, attentions and hidden_states when required
            if return_dict_in_generate:
                if output_scores:
                    scores += (next_token_scores,)
                if output_attentions:
                    decoder_attentions += (
                        (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)
                    )
                    if self.config.is_encoder_decoder:
                        cross_attentions += (outputs.cross_attentions,)

                if output_hidden_states:
                    decoder_hidden_states += (
                        (outputs.decoder_hidden_states,) if self.config.is_encoder_decoder else (outputs.hidden_states,)
                    )

            ### REPLUG
            # Sample from the normalized "logits", assuming the REPLUG processor was used!
            probs = nn.functional.softmax(next_token_scores, axis=-1)
            next_tokens = paddle.multinomial(probs, num_samples=1).squeeze(-1)
            # Lock same next-token for all examples in batch
            next_tokens[:] = next_tokens[0]

            # finished sentences should have their next token be a padding token
            if eos_token_id is not None:
                if pad_token_id is None:
                    raise ValueError("If `eos_token_id` is defined, make sure that `pad_token_id` is defined.")
                next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)

            # update generated ids, model inputs, and length for next step
            input_ids = paddle.concat([input_ids, next_tokens[:, None]], axis=-1)
            if streamer is not None:
                streamer.put(next_tokens.cpu())
            model_kwargs = self._update_model_kwargs_for_generation(
                outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder
            )

            # if eos_token was found in one sentence, set sentence to finished
            if eos_token_id_tensor is not None:
                unfinished_sequences = unfinished_sequences.mul(
                    next_tokens.tile(eos_token_id_tensor.shape[0], 1).not_equal(eos_token_id_tensor.unsqueeze(1)).prod(axis=0)
                )

                # stop when each sentence is finished
                if unfinished_sequences.max() == 0:
                    this_peer_finished = True

            # stop if we exceed the maximum length
            if stopping_criteria(input_ids, scores):
                this_peer_finished = True

            if this_peer_finished and not synced_gpus:
                break

        if streamer is not None:
            streamer.end()

        return input_ids

class REPLUGLogitsProcessor(LogitsProcessor):
    """
    Merge logits of different docs in one batch.

    Reference: fastRAG
    """

    def __init__(self, doc_scores: paddle.Tensor):
        self.num_docs = doc_scores.shape[0]
        # normalize
        doc_scores /= doc_scores.sum()
        self.doc_scores = paddle.unsqueeze(doc_scores, 1)  # k*1

    def __call__(self, input_ids, scores):
        # doc_score: k*1, scores: k*vocab_size
        replug_scores = self.doc_scores * scores
        replug_scores = replug_scores.sum(axis=0)  # 1*vocab_size
        replug_scores = paddle.tile(replug_scores, (self.num_docs, 1))  # k*vocab_size
        return replug_scores


def load_replug_model(name_or_path):
    class HF_REPLUG:
        "Creates a HF model that inherits from REPLUG_Generation class"

        def __new__(cls, name_or_path, **kwargs):
            return factory(name_or_path).from_pretrained(name_or_path, **kwargs)

    def factory(name_or_path):
        loadedConfig = AutoConfig.from_pretrained(name_or_path)
        try:
            pretrained_class_object = getattr(paddlenlp.transformers, loadedConfig.architectures[0])
            # if pretrained_class_object not in MODEL_FOR_CAUSAL_LM_MAPPING.values():
                # raise ValueError(f"Model {pretrained_class_object} is not used for causal LM generation.")
        except AttributeError:
            raise ValueError("Transformers architecture unknown.")

        class HF(pretrained_class_object, REPLUG_Generation):
            """Wrapper around HuggingFace transformers with REPLUG generation."""

            _keys_to_ignore_on_load_unexpected = [r"cls"]
            _tied_weights_keys = ["lm_head.weight"]

        return HF

    return HF_REPLUG(name_or_path)
